package com.example.commen.utile;

import static com.example.commen.resource.CommentContect.regular.businessLicense;
import static com.example.commen.resource.CommentContect.regular.emailPatternSimple;
import static com.example.commen.resource.CommentContect.regular.idCardPattern;
import static com.example.commen.resource.CommentContect.regular.passPortPattern;
import static java.util.regex.Pattern.matches;


import com.blankj.utilcode.util.LogUtils;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Create by on wsy on 2019/3/20 10:31
 */
public class CommonStringUtils {
    private CommonStringUtils() {
        throw new UnsupportedOperationException("u can't instantiate me...");
    }

    /**
     * 字符串拼接,线程安全
     */
    public static String buffer(String... array) {
        StringBuffer s = new StringBuffer();
        for (String str : array) {
            s.append(str);
        }
        return s.toString();
    }

    /**
     * 字符串拼接,线程不安全,效率高
     */
    public static String builder(String... array) {
        StringBuilder s = new StringBuilder();
        for (String str : array) {
            s.append(str);
        }
        return s.toString();
    }


    /**
     * 判断字符串是否为null或长度为0
     *
     * @param s 待校验字符串
     * @return {@code true}: 空<br> {@code false}: 不为空
     */
    public static boolean isEmpty(CharSequence s) {
        return s == null || s.length() == 0;
    }

    /**
     * 判断字符串是否为null或全为空格
     *
     * @param s 待校验字符串
     * @return {@code true}: null或全空格<br> {@code false}: 不为null且不全空格
     */
    public static boolean isSpace(String s) {
        return (s == null || s.trim().length() == 0);
    }

    /**
     * 判断两字符串是否相等
     *
     * @param a 待校验字符串a
     * @param b 待校验字符串b
     * @return {@code true}: 相等<br>{@code false}: 不相等
     */
    public static boolean equals(CharSequence a, CharSequence b) {
        if (a == b) return true;
        int length;
        if (a != null && b != null && (length = a.length()) == b.length()) {
            if (a instanceof String && b instanceof String) {
                return a.equals(b);
            } else {
                for (int i = 0; i < length; i++) {
                    if (a.charAt(i) != b.charAt(i)) return false;
                }
                return true;
            }
        }
        return false;
    }

    /**
     * 判断两字符串忽略大小写是否相等
     *
     * @param a 待校验字符串a
     * @param b 待校验字符串b
     * @return {@code true}: 相等<br>{@code false}: 不相等
     */
    public static boolean equalsIgnoreCase(String a, String b) {
        return (a == b) || (b != null) && (a.length() == b.length()) && a.regionMatches(true, 0, b, 0, b.length());
    }

    /**
     * null转为长度为0的字符串
     *
     * @param s 待转字符串
     * @return s为null转为长度为0字符串，否则不改变
     */
    public static String null2Length0(String s) {
        return s == null ? "" : s;
    }

    /**
     * 返回字符串长度
     *
     * @param s 字符串
     * @return null返回0，其他返回自身长度
     */
    public static int length(CharSequence s) {
        return s == null ? 0 : s.length();
    }

    /**
     * 首字母大写
     *
     * @param s 待转字符串
     * @return 首字母大写字符串
     */
    public static String upperFirstLetter(String s) {
        if (isEmpty(s) || !Character.isLowerCase(s.charAt(0))) return s;
        return String.valueOf((char) (s.charAt(0) - 32)) + s.substring(1);
    }

    /**
     * 首字母小写
     *
     * @param s 待转字符串
     * @return 首字母小写字符串
     */
    public static String lowerFirstLetter(String s) {
        if (isEmpty(s) || !Character.isUpperCase(s.charAt(0))) return s;
        return String.valueOf((char) (s.charAt(0) + 32)) + s.substring(1);
    }

    /**
     * 反转字符串
     *
     * @param s 待反转字符串
     * @return 反转字符串
     */
    public static String reverse(String s) {
        int len = length(s);
        if (len <= 1) return s;
        int mid = len >> 1;
        char[] chars = s.toCharArray();
        char c;
        for (int i = 0; i < mid; ++i) {
            c = chars[i];
            chars[i] = chars[len - i - 1];
            chars[len - i - 1] = c;
        }
        return new String(chars);
    }

    /**
     * 转化为半角字符
     *
     * @param s 待转字符串
     * @return 半角字符串
     */
    public static String toDBC(String s) {
        if (isEmpty(s)) return s;
        char[] chars = s.toCharArray();
        for (int i = 0, len = chars.length; i < len; i++) {
            if (chars[i] == 12288) {
                chars[i] = ' ';
            } else if (65281 <= chars[i] && chars[i] <= 65374) {
                chars[i] = (char) (chars[i] - 65248);
            } else {
                chars[i] = chars[i];
            }
        }
        return new String(chars);
    }

    /**
     * 转化为全角字符
     *
     * @param s 待转字符串
     * @return 全角字符串
     */
    public static String toSBC(String s) {
        if (isEmpty(s)) return s;
        char[] chars = s.toCharArray();
        for (int i = 0, len = chars.length; i < len; i++) {
            if (chars[i] == ' ') {
                chars[i] = (char) 12288;
            } else if (33 <= chars[i] && chars[i] <= 126) {
                chars[i] = (char) (chars[i] + 65248);
            } else {
                chars[i] = chars[i];
            }
        }
        return new String(chars);
    }

    /**
     * 验证是否是手机号码
     *
     * @param str 需要判断的字符串
     * @return 是手机号码返回true
     */
    public static boolean isPhoneNumber(String str) {
        String regex = "^[1][3|4|5|6|7|8][0-9]{9}$";
        Pattern pattern = Pattern.compile(regex);
        Matcher isPhone = pattern.matcher(str);
        return isPhone.matches();
    }
    /*** 验证电话号码
     * @return 如果是符合格式的字符串, 返回 <b>true </b>,否则为 <b>false </b>
     */
    public static boolean IsTelephone(String str) {
        String regex = "^0(10|2[0-5789]-|\\d{3})-?\\d{7,8}$";
        LogUtils.e("TAG" + "phoneNum4:" + matches(regex, str));
        return matches(regex, str);
    }
    /**
     * 验证是否是邮箱
     *
     * @param str 需要判断的字符串
     * @return 是邮箱返回true
     */
    public static boolean isEmailPatternSimple(String str) {
        String regex = emailPatternSimple;
        Pattern pattern = Pattern.compile(regex);
        Matcher isPhone = pattern.matcher(str);
        return isPhone.matches();
    }
    /**
     * 验证是否是身份证
     *
     * @param str 需要判断的字符串
     * @return 是身份证返回true
     */
    public static boolean idCardPattern(String str) {
        String regex = idCardPattern;
        Pattern pattern = Pattern.compile(regex);
        Matcher isPhone = pattern.matcher(str);
        return isPhone.matches();
    }
    /**
     * 验证是否是护照
     *
     * @param str 需要判断的字符串
     * @return 是护照返回true
     */
    public static boolean isPassPortPattern(String str) {
        String regex = passPortPattern;
        Pattern pattern = Pattern.compile(regex);
        Matcher isPhone = pattern.matcher(str);
        return isPhone.matches();
    }
    /**
     * 验证是否是营业执照
     *
     * @param str 需要判断的字符串
     * @return 是营业执照返回true
     */
    public static boolean isBusinessLicense(String str) {
        String regex = businessLicense;
        Pattern pattern = Pattern.compile(regex);
        Matcher isPhone = pattern.matcher(str);
        return isPhone.matches();
    }

    /**
        [函数名]checkUSCC
        [功能]校验18位统一社会信用代码正确性
        [参数]testUSCC:待校验的统一社会信用代码（要求字母已经保持大写）
        [返回值]boolean类型，0(false)表示验证未通过，1(true)表示验证通过
        */
    public static boolean checkUSCC(String testUSCC)
    {
        if(testUSCC.length()!=18)
        {
            System.out.println("统一社会信用代码长度错误");
            return false;
        }

        int Weight[]= {1,3,9,27,19,26,16,17,20,29,25,13,8,24,10,30,28};		//用于存放权值
        int index=0;														//用于计算当前判断的统一社会信用代码位数
        char testc;															//用于存放当前位的统一社会信用代码
        int tempSum=0;														//用于存放代码字符和加权因子乘积之和
        int tempNum=0;
        for(index=0;index<=16;index++)
        {
            testc=testUSCC.charAt(index);

            if(index==0)
            {
                if(testc!='1'&&testc!='5'&&testc!='9'&&testc!='Y')
                {
                    System.out.println("统一社会信用代码中登记管理部门代码错误");
                    return false;
                }
            }

            if(index==1)
            {
                if(testc!='1'&&testc!='2'&&testc!='3'&&testc!='9')
                {
                    System.out.println("统一社会信用代码中机构类别代码错误");
                    return false;
                }
            }

            tempNum=charToNum(testc);
            if(tempNum!=-1)								//验证代码中是否有错误字符
            {
                tempSum+=Weight[index]*tempNum;
            }
            else
            {
                System.out.println("统一社会信用代码中出现错误字符");
                return false;
            }
        }
        tempNum=31-tempSum%31;
        if(tempNum==31)  tempNum=0;
        if(charToNum(testUSCC.charAt(17))==tempNum)			//按照GB/T 17710标准对统一社会信用代码前17位计算校验码，并与第18位校验位进行比对
            return true;
        else
            return false;
    }
    /**
    [函数名]charToNum
    [功能]按照GB32100-2015标准代码字符集将用于检验的字符变为相应数字
    [参数]c:待转换的字符
    [返回值]转换完成后对应的数字,若无法找到字符集中字符，返回-1
    */
    private static int charToNum(char c)
    {
        switch (c)
        {
            case '0':
                return 0;
            case '1':
                return 1;
            case '2':
                return 2;
            case '3':
                return 3;
            case '4':
                return 4;
            case '5':
                return 5;
            case '6':
                return 6;
            case '7':
                return 7;
            case '8':
                return 8;
            case '9':
                return 9;
            case 'A':
                return 10;
            case 'B':
                return 11;
            case 'C':
                return 12;
            case 'D':
                return 13;
            case 'E':
                return 14;
            case 'F':
                return 15;
            case 'G':
                return 16;
            case 'H':
                return 17;
            case 'J':
                return 18;
            case 'K':
                return 19;
            case 'L':
                return 20;
            case 'M':
                return 21;
            case 'N':
                return 22;
            case 'P':
                return 23;
            case 'Q':
                return 24;
            case 'R':
                return 25;
            case 'T':
                return 26;
            case 'U':
                return 27;
            case 'W':
                return 28;
            case 'X':
                return 29;
            case 'Y':
                return 30;
            default:
                return -1;
        }
    }

    /**
     * @param number 号码
     * @return XXX****XXXX
     */
    public static String secretNumber(String number) {
        try {
            return number.substring(0, 3).concat("****")
                    .concat(number.substring(7, number.length()));
        } catch (Exception e) {
            return "";
        }

    }

    /**
     * 除 100 保留两位小数
     */
    public static String formatSum(Object d) {

        try {
            return String.format("%.2f", (double) d / 100);
        } catch (Exception e) {
            return "0.00";
        }

    }

    /**
     * 转换格式保留两位小数
     */
    public static String formatMoney(String d) {

        try {
            return String.format("%.2f", Double.parseDouble(d));
        } catch (Exception e) {
            return "0.00";
        }

    }
    //校验密码规则
//    这个正则表达式的含义是：
//   ^ 表示字符串的开始
//   (?=.*[0-9]) 表示密码中至少包含一个数字
//   (?=.*[a-zA-Z]) 表示密码中至少包含一个小写或大写字母
//   (?=.*_) 表示密码中至少包含一个下划线
//   .{6,} 表示密码长度至少为6个字符
//   $ 表示字符串的结束
    public static boolean validatePassword(String password) {
        String regex = "^(?=.*[0-9])(?=.*[a-zA-Z]).{6,16}$";
        return password.matches(regex);
    }
}
